home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / plnk081.zip / pilot-link.0.8.1 / validate.cc < prev   
C/C++ Source or Header  |  1997-08-02  |  7KB  |  254 lines
  1. // This files serves no use as a program for you to run.  It is simply used
  2. // for validation of the function in the classes provided
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <iostream.h>
  7. #include <unistd.h>
  8. #include <errno.h>
  9. #include "pi-source.h"
  10. #include "pi-file.h"
  11. #include "pi-todo.h"    
  12. #include "pi-memo.h"    
  13. #include "pi-datebook.h"
  14. #include "pi-address.h"
  15.  
  16. typedef void (*funcPtr_t)(void *);
  17.  
  18. void dump (void *buf, int n) {
  19.      int i, j, c;
  20.      
  21.      for (i = 0; i < n; i += 16) {
  22.       printf ("%04x: ", i);
  23.       for (j = 0; j < 16; j++) {
  24.            if (i+j < n)
  25.             printf ("%02x ", ((unsigned char *)buf)[i+j]);
  26.            else
  27.             printf ("   ");
  28.       }
  29.       printf ("  ");
  30.       for (j = 0; j < 16 && i+j < n; j++) {
  31.            c = ((unsigned char *)buf)[i+j] & 0x7f;
  32.            if (c < ' ' || c >= 0x7f)
  33.             putchar ('.');
  34.            else
  35.             putchar (c);
  36.       }
  37.       printf ("\n");
  38.      }
  39. }
  40.  
  41. // This makes sure all the data matches.  It compares with what Ken gets
  42. // so that, if mine is wrong, I can tell if it's my code or his code.
  43. void compare(void *fromPilot, int pilotSize, void *pack1, int pack1size, void *pack2, int pack2size, void *kenPack, int kenPackSize) 
  44. {
  45.      if (pack1size != pack2size) {
  46.       cerr << "Pack with malloc returned a size of " << pack1size << endl;
  47.       cerr << "Pack with buffer returned a size of " << pack2size << endl;
  48.       return;
  49.      }
  50.  
  51.      if (pack1size != pilotSize) {
  52.       cerr << "My pack routine gave a size of " << pack1size << endl;
  53.       cerr << "Pilot's packed buffer had size " << pilotSize << endl;
  54.       return;
  55.      }
  56.  
  57.      if (pack1size != kenPackSize) {
  58.       cerr << "My pack routine gave a size of " << pack1size << endl;
  59.       cerr << "Ken's pack routine had size of " << kenPackSize << endl;
  60.       // If we get here, it just means ken got it wrong, not me.  Go on
  61.      }
  62.  
  63.      if (memcmp(pack1, pack2, pack1size)) {
  64.       cerr << "My two pack routines produced different data!" << endl;
  65.       return;
  66.      }
  67.  
  68.      if (memcmp(pack1, fromPilot, pack1size)) {
  69.       cerr << "My data is different from the pilot data" << endl;
  70.       dump(pack1, pack1size);
  71.       dump(fromPilot, pilotSize);
  72.       return;
  73.      }
  74.  
  75.      if (memcmp(pack1, kenPack, pack1size)) 
  76.       cerr << "Ken's packed data differs from the pilot" << endl;
  77. }
  78.  
  79. unsigned char packedBuf[0xffff], kenBuf[0xffff];
  80. int size, packedSize1, packedSize2, kenSize, nentries, entnum;
  81. void *packed;
  82.  
  83. void memos(void *buf) 
  84. {
  85.      memo_t memo(buf);
  86.      
  87.      packed = memo.pack(&packedSize1);
  88.      
  89.      packedSize2 = sizeof(packedBuf);
  90.      if (memo.pack(packedBuf, &packedSize2) == NULL) {
  91.       cerr << "Record number " << (entnum + 1) << " too big for "
  92.            << "the buffer you passed in." << endl;
  93.       return;
  94.      }
  95.      
  96.      Memo m;
  97.      unpack_Memo(&m, (unsigned char *) buf, size);
  98.      kenSize = pack_Memo(&m, kenBuf, 0xffff);
  99.      free_Memo(&m);
  100.      
  101.      compare(buf, size, packed, packedSize1,
  102.          packedBuf, packedSize2, kenBuf, kenSize);
  103.      
  104.      delete packed;
  105. }
  106.  
  107. void todos(void *buf) 
  108. {
  109.      todo_t todo(buf);
  110.      
  111.      packed = todo.pack(&packedSize1);
  112.      
  113.      packedSize2 = sizeof(packedBuf);
  114.      todo.pack(packedBuf, &packedSize2);
  115.      
  116.      ToDo m;
  117.      unpack_ToDo(&m, (unsigned char *) buf, size);
  118.      kenSize = pack_ToDo(&m, kenBuf, 0xffff);
  119.      free_ToDo(&m);
  120.      
  121.      compare(buf, size, packed, packedSize1,
  122.          packedBuf, packedSize2, kenBuf, kenSize);
  123.      
  124.      delete packed;
  125. }
  126.  
  127. void appointments(void *buf) 
  128. {
  129.      appointment_t appointment(buf);
  130.  
  131.      packed = appointment.pack(&packedSize1);
  132.      
  133.      // Fake packed + 7, as it's not used
  134.      unsigned char *ptr = (unsigned char *) buf;
  135.      *(((unsigned char *)packed) + 7) = *(ptr + 7);
  136.      
  137.      packedSize2 = sizeof(packedBuf);
  138.      if (appointment.pack(packedBuf, &packedSize2) == NULL) {
  139.       cerr << "Record number " << (entnum + 1) << " too big for "
  140.            << "the buffer you passed in." << endl;
  141.       return;
  142.      }
  143.      packedBuf[7] = *(ptr + 7);
  144.      
  145.      Appointment m;
  146.      unpack_Appointment(&m, ptr, size);
  147.      kenSize = pack_Appointment(&m, kenBuf, 0xffff);
  148.      free_Appointment(&m);
  149.      kenBuf[7] = *(ptr + 7);
  150.      
  151.      // Fake the byte just before the description.  It's not used
  152.      if (appointment.repeatType() != appointment_t::none) {
  153.       int fakePos = 15;
  154.       if (appointment.hasAlarm()) 
  155.            fakePos += 2;
  156.       
  157.       *(((unsigned char *)packed) + fakePos) = *(ptr + fakePos);
  158.       packedBuf[fakePos] = *(ptr + fakePos);
  159.       kenBuf[fakePos] = *(ptr + fakePos);
  160.      }
  161.  
  162.      compare(buf, size, packed, packedSize1,
  163.          packedBuf, packedSize2, kenBuf, kenSize);
  164.      
  165.      delete packed;
  166. }
  167.      
  168. void addresses(void *buf) 
  169. {
  170.      address_t address(buf);
  171.      
  172.      packed = address.pack(&packedSize1);
  173.      
  174.      // buf[0] is gapfill, so make them match
  175.      unsigned char *ptr = (unsigned char *) buf;
  176.      
  177.      *(((unsigned char *) packed)) = *ptr;
  178.      
  179.      packedSize2 = sizeof(packedBuf);
  180.      if (address.pack(packedBuf, &packedSize2) == NULL) {
  181.       cerr << "Record number " << (entnum + 1) << " too big for "
  182.            << "the buffer you passed in." << endl;
  183.       return;
  184.      }
  185.      packedBuf[0] = *ptr;
  186.      
  187.      Address m;
  188.      unpack_Address(&m, (unsigned char *) buf, size);
  189.      kenSize = pack_Address(&m, kenBuf, 0xffff);
  190.      free_Address(&m);
  191.      kenBuf[0] = *ptr;
  192.      
  193.      compare(buf, size, packed, packedSize1,
  194.          packedBuf, packedSize2, kenBuf, kenSize);
  195.      
  196.      delete packed;
  197. }
  198.  
  199. /* ARGSUSED */
  200. int main(int argc, char **argv)
  201. {
  202.      chdir("/afs/pdx/u/g/r/grosch/.xusrpilot/backup");
  203.  
  204.      struct {
  205.       char *db;
  206.       funcPtr_t func;
  207.      } *aptr, apps[] = {
  208.       { "MemoDB.pdb", memos },
  209.       { "ToDoDB.pdb", todos },
  210.       { "DatebookDB.pdb", appointments },
  211.       { "AddressDB.pdb", addresses },
  212.       { NULL, NULL }
  213.      };
  214.  
  215.      void *app_info, *buf;
  216.      int app_info_size, attrs;
  217.      pi_file *pf;
  218.      
  219.      for (aptr = &apps[0]; aptr->db; aptr++) {
  220.       cout << "Examining " << aptr->db << endl;
  221.       
  222.       if ((pf = pi_file_open(aptr->db)) == NULL) {
  223.            cerr << "\tUnable to open " << aptr->db << ": " 
  224.             << strerror(errno) << endl;
  225.            continue;
  226.       }
  227.  
  228.       if (pi_file_get_app_info(pf, &app_info, &app_info_size) < 0) {
  229.            cerr << "Unable to get app info" << endl;
  230.            continue;
  231.       }
  232.       
  233.       pi_file_get_entries(pf, &nentries);
  234.       
  235.       for (int entnum = 0; entnum < nentries; entnum++) {
  236.            if (pi_file_read_record(pf, entnum, (void **) &buf, &size,
  237.                        &attrs, NULL, NULL) < 0) {
  238.             cout << "Error reading record number " << entnum << endl;
  239.             continue;
  240.            }
  241.            
  242.            if ((attrs & dlpRecAttrDeleted) || (attrs & dlpRecAttrArchived))
  243.             continue;
  244.  
  245.            (*(aptr->func))(buf);
  246.       }
  247.       
  248.       pi_file_close(pf);
  249.      }
  250.      
  251.      return 0;
  252. }
  253.  
  254.